JavaScript Async Iterator Helper એરર પ્રોપેગેશન: મજબૂત એપ્લિકેશન્સ માટે સ્ટ્રીમ એરર હેન્ડલિંગ

            async function* createAsyncIterator(data) {
  for (const item of data) {
    await new Promise(resolve => setTimeout(resolve, 50)); // Simulate asynchronous operation
    yield item;
  }
}

const asyncIterator = createAsyncIterator([1, 2, 3]);

async function consumeIterator() {
  let result = await asyncIterator.next();
  while (!result.done) {
    console.log(result.value);
    result = await asyncIterator.next();
  }
}

consumeIterator(); // Output: 1, 2, 3 (with delays)
            

              
                Copy
              
            
          

            async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate asynchronous operation
    yield i;
  }
}

async function consumeGenerator() {
  for await (const num of generateSequence(1, 5)) {
    console.log(num);
  }
}

consumeGenerator(); // Output: 1, 2, 3, 4, 5 (with delays)
            

              
                Copy
              
            
          

            async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Error fetching data from ${url}:`, error);
      // Optionally, yield a fallback value or re-throw the error
      yield { error: error.message, url: url }; // Yield an error object
    }
  }
}

async function consumeData() {
  for await (const item of fetchData(['https://example.com/data1', 'https://example.com/data2'])) {
    if (item.error) {
      console.warn(`Encountered an error for URL: ${item.url}, Error: ${item.error}`);
    } else {
      console.log('Received data:', item);
    }
  }
}

consumeData();
            

              
                Copy
              
            
          

            async function* fetchData(urls) {
  for (const url of urls) {
    const promise = fetch(url)
      .then(response => {
        if (!response.ok) {
          throw new Error(`HTTP error! status: ${response.status}`);
        }
        return response.json();
      })
      .catch(error => {
        console.error(`Error fetching data from ${url}:`, error);
        return { error: error.message, url: url }; // Return an error object
      });

    yield await promise;
  }
}

async function consumeData() {
  for await (const item of fetchData(['https://example.com/data1', 'https://example.com/data2'])) {
    if (item.error) {
      console.warn(`Encountered an error for URL: ${item.url}, Error: ${item.error}`);
    } else {
      console.log('Received data:', item);
    }
  }
}

consumeData();
            

              
                Copy
              
            
          

            async function safeFetch(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return await response.json();
  } catch (error) {
    console.error(`Error fetching data from ${url}:`, error);
    return { error: error.message, url: url }; // Return an error object
  }
}

async function* fetchData(urls) {
  for (const url of urls) {
    yield await safeFetch(url);
  }
}

async function consumeData() {
  for await (const item of fetchData(['https://example.com/data1', 'https://example.com/data2'])) {
    if (item.error) {
      console.warn(`Encountered an error for URL: ${item.url}, Error: ${item.error}`);
    } else {
      console.log('Received data:', item);
    }
  }
}

consumeData();
            

              
                Copy
              
            
          

            async function* generateNumbers(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

async function consumeData() {
  try {
    const asyncIterable = generateNumbers(5);

    const mappedIterable = asyncIterable.map(async (num) => {
      if (num === 3) {
        throw new Error('Error processing number 3');
      }
      return num * 2;
    });

    for await (const item of mappedIterable) {
      console.log(item);
    }
  } catch (error) {
    console.error('An error occurred:', error);
  }
}

consumeData(); // Output: 2, 4, An error occurred: Error: Error processing number 3
            

              
                Copy
              
            
          

            async function* generateNumbers(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

async function consumeData() {
  try {
    const asyncIterable = generateNumbers(5);

    const filteredIterable = asyncIterable.filter(async (num) => {
      if (num === 3) {
        throw new Error('Error filtering number 3');
      }
      return num % 2 === 0;
    });

    for await (const item of filteredIterable) {
      console.log(item);
    }
  } catch (error) {
    console.error('An error occurred:', error);
  }
}

consumeData(); // Output: An error occurred: Error: Error filtering number 3
            

              
                Copy
              
            
          

            async function* generateNumbers(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

async function consumeData() {
  try {
    const asyncIterable = generateNumbers(5);

    const sum = await asyncIterable.reduce(async (acc, num) => {
      if (num === 3) {
        throw new Error('Error reducing number 3');
      }
      return acc + num;
    }, 0);

    console.log('Sum:', sum);
  } catch (error) {
    console.error('An error occurred:', error);
  }
}

consumeData(); // Output: An error occurred: Error: Error reducing number 3
            

              
                Copy
              
            
          

            process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
  // Optionally, perform cleanup or exit the process
});

async function* generateNumbers(n) {
  for (let i = 1; i <= n; i++) {
    if (i === 3) {
      throw new Error('Simulated Error'); // This will cause an unhandled rejection if not caught locally
    }
    yield i;
  }
}

async function main() {
  const iterator = generateNumbers(5);
  for await (const num of iterator) {
    console.log(num);
  }
}

main(); // Will trigger 'unhandledRejection' if the error inside generator isn't handled.
            

              
                Copy
              
            
          

            window.addEventListener('unhandledrejection', (event) => {
  console.error('Unhandled rejection:', event.reason, event.promise);
  // You can log the error or display a user-friendly message here.
});

async function fetchData(url) {
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`); // Might cause unhandled rejection if `fetchData` isn't wrapped in try/catch
  }
  return response.json();
}

async function processData() {
  const data = await fetchData('https://example.com/api/nonexistent'); // URL likely to cause an error.
  console.log(data);
}

processData();
            

              
                Copy
              
            
          

            async function safeFetch(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return await response.json();
  } catch (error) {
    console.error(`Error fetching data from ${url}:`, error);
    return null; // Indicate failure
  }
}

async function* fetchDataWithFallback(apiUrls, fallbackUrl) {
  for (const apiUrl of apiUrls) {
    let data = await safeFetch(apiUrl);
    if (data === null) {
      console.log(`Attempting fallback for ${apiUrl}`);
      data = await safeFetch(fallbackUrl);
      if (data === null) {
        console.warn(`Fallback also failed for ${apiUrl}. Returning default value.`);
        yield { error: `Failed to fetch data from ${apiUrl} and fallback.` };
        continue; // Skip to the next URL
      }
    }
    yield data;
  }
}

async function processData() {
  const apiUrls = ['https://api.example.com/data1', 'https://api.nonexistent.com/data2', 'https://api.example.com/data3'];
  const fallbackUrl = 'https://backup.example.com/default_data';
  for await (const item of fetchDataWithFallback(apiUrls, fallbackUrl)) {
    if (item.error) {
      console.warn(`Error processing data: ${item.error}`);
    } else {
      console.log('Processed data:', item);
    }
  }
}

processData();
            

              
                Copy
              
            
          

            const rateLimit = 5; // Number of requests per second
let requestCount = 0;
let lastRequestTime = 0;

async function throttledFetch(url) {
  const now = Date.now();
  if (requestCount >= rateLimit && now - lastRequestTime < 1000) {
    const delay = 1000 - (now - lastRequestTime);
    console.log(`Rate limit exceeded. Waiting ${delay}ms...`);
    await new Promise(resolve => setTimeout(resolve, delay));
  }

  try {
    const response = await fetch(url);
    if (response.status === 429) { // Rate limit exceeded
      console.warn('Rate limit exceeded. Retrying after a delay...');
      await new Promise(resolve => setTimeout(resolve, 2000)); // Wait longer
      return throttledFetch(url); // Retry
    }

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    requestCount++;
    lastRequestTime = Date.now();
    return data;

  } catch (error) {
    console.error(`Error fetching ${url}:`, error);
    throw error; // Re-throw the error after logging
  }
}

async function* fetchUrls(urls) {
  for (const url of urls) {
    try {
      yield await throttledFetch(url);
    } catch (err) {
      console.error(`Failed to fetch URL ${url} after retries. Skipping.`);
      yield { error: `Failed to fetch ${url}` }; // Signal error to consumer
    }
  }
}

async function consumeData() {
  const urls = ['https://api.example.com/resource1', 'https://api.example.com/resource2', 'https://api.example.com/resource3'];
  for await (const item of fetchUrls(urls)) {
    if (item.error) {
      console.warn(`Error: ${item.error}`);
    } else {
      console.log('Data:', item);
    }
  }
}

consumeData();
            

              
                Copy